import request from '@/utils/request'
import { repairTaskStatusToCode, repairTaskCodeToStatus, calculateRepairStatus } from '@/utils/statusConverter'

// 格式化日期显示，去掉时间部分
function formatDateDisplay(dateString) {
  if (!dateString) return null;
  // 只保留日期部分，去掉时间部分
  return dateString.split(' ')[0];
}

// 查询维修任务列表
export function listRepairTask(query) {
  // 转换查询参数中的状态文本为状态码
  const params = { ...query };
  if (params.status && typeof params.status === 'string') {
    params.statusText = params.status;
    params.status = repairTaskStatusToCode(params.status);
  }
  
  return request({
    url: '/qep/repair-task/list',
    method: 'get',
    params
  }).then(res => {
    // 转换返回数据中的状态码为状态文本，并根据时间计算实际状态
    if (res.rows && res.rows.length > 0) {
      res.rows.forEach(item => {
        // 计算实际状态
        const calculatedStatus = calculateRepairStatus(item.actualStartTime, item.actualEndTime);
        // 更新状态值
        item.status = calculatedStatus.code;
        item.statusText = calculatedStatus.text;
        
        // 格式化日期显示（只显示日期部分）
        if (item.planStartTime) item.planStartTimeDisplay = formatDateDisplay(item.planStartTime);
        if (item.planEndTime) item.planEndTimeDisplay = formatDateDisplay(item.planEndTime);
        if (item.actualStartTime) item.actualStartTimeDisplay = formatDateDisplay(item.actualStartTime);
        if (item.actualEndTime) item.actualEndTimeDisplay = formatDateDisplay(item.actualEndTime);
      });
    }
    return res;
  });
}

// 查询维修任务详细
export function getRepairTask(id) {
  return request({
    url: '/qep/repair-task/' + id,
    method: 'get'
  }).then(res => {
    // 计算实际状态
    if (res.data) {
      const calculatedStatus = calculateRepairStatus(res.data.actualStartTime, res.data.actualEndTime);
      res.data.status = calculatedStatus.code;
      res.data.statusText = calculatedStatus.text;
      
      // 不再格式化日期（保留完整时间）
    }
    return res;
  });
}

// 根据不合格品ID查询维修任务
export function getRepairTaskByNonconformingId(nonconformingId) {
  return request({
    url: '/qep/repair-task/nonconforming/' + nonconformingId,
    method: 'get'
  }).then(res => {
    // 计算实际状态
    if (res.data) {
      const calculatedStatus = calculateRepairStatus(res.data.actualStartTime, res.data.actualEndTime);
      res.data.status = calculatedStatus.code;
      res.data.statusText = calculatedStatus.text;
      
      // 不再格式化日期（保留完整时间）
    }
    return res;
  });
}

// 新增维修任务
export function addRepairTask(data) {
  const postData = { ...data };
  
  // 根据实际时间计算状态
  const calculatedStatus = calculateRepairStatus(postData.actualStartTime, postData.actualEndTime);
  postData.status = calculatedStatus.code;
  postData.statusText = calculatedStatus.text;
  
  // 修正日期格式 - 确保所有日期符合后端要求的格式 (yyyy-MM-dd HH:mm:ss)
  const formatDate = (dateStr) => {
    if (!dateStr) return null;
    
    try {
      // 如果已经是标准格式，则不变
      if (typeof dateStr === 'string' && 
          /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(dateStr)) {
        return dateStr;
      }
      
      // 处理各种日期格式
      let date;
      if (typeof dateStr === 'string') {
        // 处理常见的日期格式问题
        // 修复格式为 "yyyy-M-d..."
        const fixedDateStr = dateStr.replace(
          /^(\d{4})-(\d{1})-(\d{1,2})/,
          (match, year, month, day) => `${year}-${month.padStart(2, '0')}-${day.padStart(2, '0')}`
        ).replace(
          /^(\d{4})-(\d{2})-(\d{1})/,
          (match, year, month, day) => `${year}-${month}-${day.padStart(2, '0')}`
        );
        
        // 尝试解析修复后的字符串
        date = new Date(fixedDateStr);
        
        // 如果解析失败，尝试其他方法
        if (isNaN(date.getTime())) {
          // 尝试分解并重构日期
          const parts = dateStr.split(/[-\s:]/);
          if (parts.length >= 6) {
            // 有完整的年月日时分秒
            const [year, month, day, hour, minute, second] = parts;
            date = new Date(
              parseInt(year, 10),
              parseInt(month, 10) - 1,
              parseInt(day, 10),
              parseInt(hour, 10),
              parseInt(minute, 10),
              parseInt(second, 10)
            );
          } else if (parts.length >= 3) {
            // 只有年月日
            const [year, month, day] = parts;
            date = new Date(
              parseInt(year, 10),
              parseInt(month, 10) - 1,
              parseInt(day, 10)
            );
          }
        }
      } else {
        // 假设是Date对象或时间戳
        date = new Date(dateStr);
      }
      
      // 验证日期是否有效
      if (isNaN(date.getTime())) {
        console.error('无效的日期格式:', dateStr);
        return null;
      }
      
      // 格式化为 yyyy-MM-dd HH:mm:ss
      const year = date.getFullYear();
      const month = String(date.getMonth() + 1).padStart(2, '0');
      const day = String(date.getDate()).padStart(2, '0');
      const hours = String(date.getHours()).padStart(2, '0');
      const minutes = String(date.getMinutes()).padStart(2, '0');
      const seconds = String(date.getSeconds()).padStart(2, '0');
      
      return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
    } catch (e) {
      console.error('日期格式化错误:', e, dateStr);
      return null;
    }
  };
  
  // 应用格式化到所有日期字段
  if (postData.planStartTime) postData.planStartTime = formatDate(postData.planStartTime);
  if (postData.planEndTime) postData.planEndTime = formatDate(postData.planEndTime);
  if (postData.actualStartTime) postData.actualStartTime = formatDate(postData.actualStartTime);
  if (postData.actualEndTime) postData.actualEndTime = formatDate(postData.actualEndTime);
  
  console.log('提交的维修任务数据:', postData);
  
  return request({
    url: '/qep/repair-task',
    method: 'post',
    data: postData
  });
}

// 修改维修任务
export function updateRepairTask(data) {
  const putData = { ...data };
  
  // 根据实际时间计算状态
  const calculatedStatus = calculateRepairStatus(putData.actualStartTime, putData.actualEndTime);
  putData.status = calculatedStatus.code;
  putData.statusText = calculatedStatus.text;
  
  // 修正日期格式 - 确保所有日期符合后端要求的格式 (yyyy-MM-dd HH:mm:ss)
  const formatDate = (dateStr) => {
    if (!dateStr) return null;
    
    try {
      // 如果已经是标准格式，则不变
      if (typeof dateStr === 'string' && 
          /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(dateStr)) {
        return dateStr;
      }
      
      // 处理各种日期格式
      let date;
      if (typeof dateStr === 'string') {
        // 处理常见的日期格式问题
        // 修复格式为 "yyyy-M-d..."
        const fixedDateStr = dateStr.replace(
          /^(\d{4})-(\d{1})-(\d{1,2})/,
          (match, year, month, day) => `${year}-${month.padStart(2, '0')}-${day.padStart(2, '0')}`
        ).replace(
          /^(\d{4})-(\d{2})-(\d{1})/,
          (match, year, month, day) => `${year}-${month}-${day.padStart(2, '0')}`
        );
        
        // 尝试解析修复后的字符串
        date = new Date(fixedDateStr);
        
        // 如果解析失败，尝试其他方法
        if (isNaN(date.getTime())) {
          // 尝试分解并重构日期
          const parts = dateStr.split(/[-\s:]/);
          if (parts.length >= 6) {
            // 有完整的年月日时分秒
            const [year, month, day, hour, minute, second] = parts;
            date = new Date(
              parseInt(year, 10),
              parseInt(month, 10) - 1,
              parseInt(day, 10),
              parseInt(hour, 10),
              parseInt(minute, 10),
              parseInt(second, 10)
            );
          } else if (parts.length >= 3) {
            // 只有年月日
            const [year, month, day] = parts;
            date = new Date(
              parseInt(year, 10),
              parseInt(month, 10) - 1,
              parseInt(day, 10)
            );
          }
        }
      } else {
        // 假设是Date对象或时间戳
        date = new Date(dateStr);
      }
      
      // 验证日期是否有效
      if (isNaN(date.getTime())) {
        console.error('无效的日期格式:', dateStr);
        return null;
      }
      
      // 格式化为 yyyy-MM-dd HH:mm:ss
      const year = date.getFullYear();
      const month = String(date.getMonth() + 1).padStart(2, '0');
      const day = String(date.getDate()).padStart(2, '0');
      const hours = String(date.getHours()).padStart(2, '0');
      const minutes = String(date.getMinutes()).padStart(2, '0');
      const seconds = String(date.getSeconds()).padStart(2, '0');
      
      return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
    } catch (e) {
      console.error('日期格式化错误:', e, dateStr);
      return null;
    }
  };
  
  // 应用格式化到所有日期字段
  if (putData.planStartTime) putData.planStartTime = formatDate(putData.planStartTime);
  if (putData.planEndTime) putData.planEndTime = formatDate(putData.planEndTime);
  if (putData.actualStartTime) putData.actualStartTime = formatDate(putData.actualStartTime);
  if (putData.actualEndTime) putData.actualEndTime = formatDate(putData.actualEndTime);
  
  console.log('更新的维修任务数据:', putData);
  
  return request({
    url: '/qep/repair-task',
    method: 'put',
    data: putData
  });
}

// 删除维修任务
export function delRepairTask(id) {
  return request({
    url: '/qep/repair-task/' + id,
    method: 'delete'
  });
}

// 统计维修任务数量
export function countRepairTask(query) {
  // 转换查询参数中的状态文本为状态码
  const params = { ...query };
  if (params.status && typeof params.status === 'string') {
    params.statusText = params.status;
    params.status = repairTaskStatusToCode(params.status);
  }
  
  return request({
    url: '/qep/repair-task/count',
    method: 'get',
    params
  });
} 